﻿using BanZuiCloudControlAgent.Core.Mqtt;
using BanZuiCloudControlAgent.Core.Mqtt.Enum;
using BanZuiCloudControlAgent.Core.Mqtt.Listener;
using BanZuiCloudControlAgent.Core.Mqtt.Models;
using BanZuiCloudControlAgent.Core.Mqtt.Sender;
using BanZuiCloudControlAgent.Core.Tasks.Handlers;
using BanZuiCloudControlAgent.Utils.Common;
using BanZuiCloudControlAgent.Utils.Logging;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using AutoUpdaterDotNET;
using System.IO;
using System.Diagnostics;
using ConnectionState = BanZuiCloudControlAgent.Core.Mqtt.Enum.ConnectionState;

namespace BanZuiCloudControlAgent.UI
{
    public partial class FrmMain : Form
    {
        private readonly Logger _logger;
        private MqttService _mqttService;
        
        // 日志查看器控件
        private LogViewer logViewer;

        // 测试控件
        private TestViewer testViewer;

        // 添加TaskExecutor成员变量
        private TaskExecutor _taskExecutor;
        
        // 添加MessageSenderMiddleware成员变量
        private MessageSenderMiddleware _messageSender;

        /// <summary>
        /// 默认构造函数，主要用于设计器
        /// </summary>
        public FrmMain()
        {
            InitializeComponent();
            _logger = LogManager.GetLogger(nameof(FrmMain));
            
            // 设置窗体标题，包含版本号
            this.Text = $"{AppConstants.AppTitle} v{AppConstants.AppVersion}";
            
            // 初始化日志查看器控件
            InitializeLogViewer();

            // 初始化 测试窗口 控件
            InitializeTestViewer();
            
            // 添加用户名文本框的TextChanged事件处理
            txtUsername.TextChanged += TxtUsername_TextChanged;
        }

        /// <summary>
        /// 带参数的构造函数，支持依赖注入
        /// </summary>
        /// <param name="logger">日志记录器</param>
        /// <param name="mqttService">MQTT服务</param>
        public FrmMain(Logger logger, MqttService mqttService = null)
        {
            InitializeComponent();
            
            _logger = logger ?? LogManager.GetLogger(nameof(FrmMain));
            _mqttService = mqttService;
            
            // 设置窗体标题，包含版本号
            this.Text = $"{AppConstants.AppTitle} v{AppConstants.AppVersion}";
            
            // 初始化日志查看器控件
            InitializeLogViewer();

            // 初始化 测试窗口 控件, 必须在日志查看器之后初始化，以确保日志查看器可以正确显示日志
            InitializeTestViewer();
            
            // 添加用户名文本框的TextChanged事件处理
            txtUsername.TextChanged += TxtUsername_TextChanged;
        }


           /// <summary>
        /// 窗体加载完成后执行
        /// </summary>
        private void FrmMain_Load(object sender, EventArgs e)
        {
            _logger.Info("主窗体加载完成");
            
            // 加载配置到UI
            LoadConfigToUI();
            
            // 不在这里初始化任务执行器
            // InitializeTaskExecutor();
            
            // 检查是否需要自动登录
            CheckAutoLogin();
        }

        /// <summary>
        /// 窗体关闭事件处理
        /// </summary>
        private void FrmMain_FormClosing(object sender, FormClosingEventArgs e)
        {
            try
            {
                _logger.Info("应用程序正在关闭...");
                
                // 停止任务执行器
                if (_taskExecutor != null)
                {
                    _taskExecutor.Stop();
                    _logger.Info("任务执行器已停止");
                }
                
                // 断开MQTT连接
                if (_mqttService != null && _mqttService.IsConnected)
                {
                    Task.Run(async () =>
                    {
                        await DisconnectMqttAsync(true, true);
                    }).Wait();
                }
                
                // 保存配置
                SaveUIConfig();
                
                // 关闭日志查看器
                if (logViewer != null && !logViewer.IsDisposed)
                {
                    logViewer.Hide();
                    logViewer.Dispose();
                }
                
                // 关闭测试查看器
                if (testViewer != null && !testViewer.IsDisposed)
                {
                    testViewer.Hide();
                    testViewer.Dispose();
                }
                
                _logger.Info("应用程序已关闭");
            }
            catch (Exception ex)
            {
                _logger.Error("关闭应用程序时发生错误", ex);
            }
        }

        /// <summary>
        /// 初始化日志查看器控件
        /// </summary>
        private void InitializeLogViewer()
        {
            // 创建日志查看器控件
            logViewer = new LogViewer();
            logViewer.Dock = DockStyle.Fill;

            // 将日志查看器控件添加到日志选项卡
            tabPageLogs.Controls.Add(logViewer);
        }

        /// <summary>
        /// 初始化测试控件
        /// </summary>
        private void InitializeTestViewer()
        {
            //// 创建测试控件
            testViewer = new TestViewer();
            testViewer.Dock = DockStyle.Fill;


            // 将 测试窗口 添加到测试选项卡
            tabPageTest.Controls.Add(testViewer);
        }

        /// <summary>
        /// 初始化消息发送中间件
        /// </summary>
        private void InitializeMessageSender()
        {
            try
            {
                // 从UI设置中获取设备码
                var uiSettings = ConfigurationManager.UI;
                
                // 确保MQTT服务已经初始化
                if (_mqttService != null)
                {
                    // 获取MQTT消息发送器
                    var mqttMessageSender = _mqttService.GetMessageSender();
                    
                    // 创建消息发送中间件
                    _messageSender = new MessageSenderMiddleware(mqttMessageSender, uiSettings.DeviceCode);
                    
                    _logger.Info("消息发送中间件已初始化");
                }
                else
                {
                    _logger.Warn("MQTT服务尚未初始化，无法初始化消息发送中间件");
                }
            }
            catch (Exception ex)
            {
                _logger.Error($"初始化消息发送中间件失败: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// 获取任务执行器
        /// </summary>
        /// <returns>任务执行器</returns>
        public TaskExecutor GetTaskExecutor()
        {
            return _taskExecutor;
        }

        /// <summary>
        /// 初始化任务执行器
        /// </summary>
        private void InitializeTaskExecutor()
        {
            try
            {
                // 从UI设置中获取设备码
                var uiSettings = ConfigurationManager.UI;
                
                // 确保消息发送中间件已经初始化
                if (_messageSender != null)
                {
                    _taskExecutor = new TaskExecutor(_logger, uiSettings.DeviceCode, _messageSender);
                    
                    // 启动任务执行器
                    _taskExecutor.Start();
                    
                    // 将任务队列设置到MQTT服务中，以便在状态上报中包含任务状态
                    if (_mqttService != null)
                    {
                        _mqttService.SetTaskQueue(_taskExecutor.GetTaskQueue());
                        _logger.Info("已将任务队列设置到MQTT服务中");
                    }
                    
                    _logger.Info("任务执行器已初始化并启动");
                }
                else
                {
                    _logger.Warn("消息发送中间件尚未初始化，无法初始化任务执行器");
                }
            }
            catch (Exception ex)
            {
                _logger.Error($"初始化任务执行器失败: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// 加载配置到UI
        /// </summary>
        private void LoadConfigToUI()
        {
            try
            {
                _logger.Info("加载配置到UI");
                
                var uiSettings = ConfigurationManager.UI;
                _logger.Info($"从配置中获取到UI设置: ServerUrl={uiSettings.ServerUrl}, ServerPort={uiSettings.ServerPort}, Username={uiSettings.Username}, DeviceName={uiSettings.DeviceName}, DeviceCode={uiSettings.DeviceCode}, UseTls={uiSettings.UseTls}");
                
                txtServerUrl.Text = uiSettings.ServerUrl;
                txtPort.Text = uiSettings.ServerPort.ToString();
                txtUsername.Text = uiSettings.Username;
                txtDeviceName.Text = uiSettings.DeviceName;
                txtPassword.Text = uiSettings.Password;
                checkBoxUseTls.Checked = uiSettings.UseTls;
                checkBoxAutoLogin.Checked = uiSettings.AutoLogin;
                
                // 显示设备码
                string deviceCode = uiSettings.DeviceCode;
                if (string.IsNullOrEmpty(deviceCode))
                {
                    deviceCode = uiSettings.Username;
                }
                lblDeviceCodeValue.Text = deviceCode;

                // 检查并设置开机自启状态
                checkBoxAutoStart.Checked = IsAutoStartEnabled();

                _logger.Info($"已加载配置到UI - 服务器: {uiSettings.ServerUrl}:{uiSettings.ServerPort}, 用户名: {uiSettings.Username}, 设备名称: {uiSettings.DeviceName}, 设备码: {deviceCode}, 自动登录: {uiSettings.AutoLogin}, 开机自启: {checkBoxAutoStart.Checked}");
                UpdateConnectionUI(ConnectionState.Disconnected);
            }
            catch (Exception ex)
            {
                _logger.Error("加载配置到UI失败", ex);
                ShowError("加载配置失败: " + ex.Message);
                
                // 使用默认值
                txtServerUrl.Text = "110.40.130.190";
                txtPort.Text = "1889";
                txtUsername.Text = "agent";
                txtDeviceName.Text = "默认设备";
                txtPassword.Text = "";
                checkBoxUseTls.Checked = false;
                checkBoxAutoLogin.Checked = false;
                checkBoxAutoStart.Checked = false;
                lblDeviceCodeValue.Text = "N/A";
                
                UpdateConnectionUI(ConnectionState.Disconnected, "加载配置失败");
            }
        }

        /// <summary>
        /// 保存UI配置
        /// </summary>
        private void SaveUIConfig()
        {
            try
            {
                _logger.Info("保存UI配置");
                
                string serverUrl = txtServerUrl.Text.Trim();
                string username = txtUsername.Text.Trim();
                string deviceName = txtDeviceName.Text.Trim();
                string password = txtPassword.Text;
                bool useTls = checkBoxUseTls.Checked;
                bool autoLogin = checkBoxAutoLogin.Checked;
                int port = 1889; // 默认端口
                
                if (int.TryParse(txtPort.Text.Trim(), out int parsedPort))
                {
                    port = parsedPort;
                }
                
                // 从用户名中提取设备码
                string deviceCode = username;
                _logger.Info($"从用户名 {username} 中提取设备码: {deviceCode}");
                
                ConfigurationManager.SetValue("UI:ServerUrl", serverUrl);
                ConfigurationManager.SetValue("UI:ServerPort", port);
                ConfigurationManager.SetValue("UI:Username", username);
                ConfigurationManager.SetValue("UI:DeviceName", deviceName);
                ConfigurationManager.SetValue("UI:Password", password);
                ConfigurationManager.SetValue("UI:UseTls", useTls);
                ConfigurationManager.SetValue("UI:DeviceCode", deviceCode);
                ConfigurationManager.SetValue("UI:AutoLogin", autoLogin);
                
                ConfigurationManager.SaveConfig();
                _logger.Info($"保存UI配置成功，设备名称: {deviceName}, 设备码: {deviceCode}, 自动登录: {autoLogin}");
            }
            catch (Exception ex)
            {
                _logger.Error("保存UI配置失败", ex);
                ShowError("保存配置失败: " + ex.Message);
            }
        }
        
        ///// <summary>
        ///// 从用户名中提取设备码
        ///// </summary>
        ///// <param name="username">用户名</param>
        ///// <returns>设备码</returns>
        //private string ExtractDeviceCodeFromUsername(string username)
        //{
        //    try
        //    {
        //        // 常见的用户名格式: device_123, agent_123, 123等
        //        if (string.IsNullOrEmpty(username))
        //        {
        //            return string.Empty;
        //        }
                
        //        // 检查是否包含下划线，如果有则提取下划线后面的部分
        //        if (username.Contains("_"))
        //        {
        //            string[] parts = username.Split('_');
        //            if (parts.Length > 1 && !string.IsNullOrEmpty(parts[1]))
        //            {
        //                return parts[1];
        //            }
        //        }
                
        //        // 检查整个用户名是否为数字
        //        if (username.All(char.IsDigit))
        //        {
        //            return username;
        //        }
                
        //        // 提取用户名中的所有数字
        //        string numbers = new string(username.Where(char.IsDigit).ToArray());
        //        if (!string.IsNullOrEmpty(numbers))
        //        {
        //            return numbers;
        //        }
                
        //        // 如果无法提取，则返回原始用户名
        //        return username;
        //    }
        //    catch (Exception ex)
        //    {
        //        _logger.Error($"从用户名提取设备码失败: {ex.Message}", ex);
        //        return username; // 出错时返回原始用户名
        //    }
        //}

        /// <summary>
        /// 连接按钮点击事件
        /// </summary>
        private async void btnConnect_Click(object sender, EventArgs e)
        {
            try
            {
                // 获取按钮文本，用于判断当前状态
                string buttonText = btnConnect.Text;

                // 如果已连接，则断开连接
                if (_mqttService != null && _mqttService.IsConnected)
                {
                    await DisconnectMqttAsync(false, false);
                    return;
                }
                
                // 如果正在连接中或重连中，则取消连接
                if (buttonText == "取消连接" || buttonText == "取消重连")
                {
                    _logger.Info("用户取消连接/重连");
                    await DisconnectMqttAsync(true, false);
                    return;
                }

                // 保存配置
                SaveUIConfig();

                // 连接MQTT服务器
                await ConnectMqttAsync();
            }
            catch (Exception ex)
            {
                _logger.Error("连接MQTT服务器失败", ex);
                ShowError("连接MQTT服务器失败: " + ex.Message);
                UpdateConnectionUI(ConnectionState.Disconnected, "连接失败: " + ex.Message);
            }
        }

        /// <summary>
        /// 连接MQTT服务器
        /// </summary>
        private async Task ConnectMqttAsync()
        {
            try
            {
                // 设置连接中状态
                UpdateConnectionUI(ConnectionState.Connecting);
                
                // 创建MQTT服务
                if (_mqttService == null)
                {
                    _logger.Info("创建新的MQTT服务实例");
                    _mqttService = new MqttService();
                    
                    // 注册事件 - 每次都重新注册，确保事件处理程序不会丢失
                    _logger.Debug("注册MQTT事件处理程序");
                }
                
                // 确保事件已注册
                // 先取消之前的注册，避免重复注册
                _mqttService.ConnectionStatusChanged -= MqttService_ConnectionStatusChanged;
                _mqttService.TaskReceived -= MqttService_TaskReceived;
                _mqttService.ConfigReceived -= MqttService_ConfigReceived;
                _mqttService.UpdateTaskReceived -= MqttService_UpdateTaskReceived;
                
                // 重新注册事件
                _mqttService.ConnectionStatusChanged += MqttService_ConnectionStatusChanged;
                _mqttService.TaskReceived += MqttService_TaskReceived;
                _mqttService.ConfigReceived += MqttService_ConfigReceived;
                _mqttService.UpdateTaskReceived += MqttService_UpdateTaskReceived;
                
                _logger.Debug("事件处理程序已注册");
                
                // 启动MQTT服务
                try
                {
                    await _mqttService.StartAsync();
                    
                    // 添加一个小延迟，等待连接事件触发
                    await Task.Delay(500);
                    
                    // 主动检查连接状态并更新UI
                    _logger.Debug($"MQTT服务启动后，主动检查连接状态: IsConnected={_mqttService.IsConnected}");
                    
                    // 如果连接成功，让ConnectionStatusChanged事件处理UI更新
                    // 但如果事件没有触发，则在这里主动更新UI
                    if (_mqttService.IsConnected)
                    {
                        _logger.Info("MQTT服务已连接，主动更新UI状态为已连接");
                        UpdateConnectionUI(ConnectionState.Connected);
                    }
                    else
                    {
                        // 如果启动后未连接，则更新UI为未连接状态
                        _logger.Warn("MQTT服务启动后未连接，更新UI状态为未连接");
                        UpdateConnectionUI(ConnectionState.Disconnected, "连接MQTT服务器失败");
                    }
                }
                catch (InvalidOperationException ex) when (ex.Message.Contains("already started"))
                {
                    _logger.Warn("MQTT客户端已经启动，继续执行");
                    
                    // 检查实际连接状态
                    if (_mqttService.IsConnected)
                    {
                        _logger.Info("MQTT客户端已启动且已连接，更新UI状态为已连接");
                        UpdateConnectionUI(ConnectionState.Connected);
                    }
                    else
                    {
                        _logger.Warn("MQTT客户端已启动但未连接，更新UI状态为未连接");
                        UpdateConnectionUI(ConnectionState.Disconnected, "MQTT客户端已启动但未连接");
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.Error("连接MQTT服务器失败", ex);
                throw;
            }
        }

        /// <summary>
        /// 断开MQTT连接
        /// </summary>
        /// <param name="isCancelReconnect">是否是取消重连</param>
        /// <param name="isClosing">是否在应用程序关闭过程中</param>
        private async Task DisconnectMqttAsync(bool isCancelReconnect = false, bool isClosing = false)
        {
            try
            {
                if (_mqttService != null)
                {
                    if (isCancelReconnect)
                    {
                        UpdateConnectionUI(ConnectionState.Disconnecting, "正在取消重连...");
                    }
                    else
                    {
                        UpdateConnectionUI(ConnectionState.Disconnecting);
                    }
                    
                    // 停止MQTT服务
                    try
                    {
                        await _mqttService.StopAsync(isCancelReconnect, isClosing);
                        
                        // 主动断开连接后，立即更新UI状态
                        if (!isClosing) // 在应用程序关闭时不再更新UI
                        {
                            if (isCancelReconnect)
                            {
                                UpdateConnectionUI(ConnectionState.Disconnected, "已取消重连");
                            }
                            else
                            {
                                UpdateConnectionUI(ConnectionState.Disconnected, "已断开MQTT连接");
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        _logger.Warn($"断开MQTT连接时发生错误: {ex.Message}");
                        
                        // 即使出错，也更新UI状态
                        if (!isClosing) // 在应用程序关闭时不再更新UI
                        {
                            if (isCancelReconnect)
                            {
                                UpdateConnectionUI(ConnectionState.Disconnected, $"取消重连时发生错误: {ex.Message}");
                            }
                            else
                            {
                                UpdateConnectionUI(ConnectionState.Disconnected, $"断开MQTT连接时发生错误: {ex.Message}");
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.Error("断开MQTT连接失败", ex);
                throw;
            }
        }

        /// <summary>
        /// MQTT连接状态变更事件处理
        /// </summary>
        private void MqttService_ConnectionStatusChanged(object sender, MqttConnectionStatusChangedEventArgs e)
        {
            try
            {
                _logger.Debug($"收到MQTT连接状态变更事件: IsConnected={e.IsConnected}, DisconnectReason={e.DisconnectReason}, ReconnectAttempts={e.ReconnectAttempts}");
                
                // 使用Invoke确保在UI线程上执行
                if (InvokeRequired)
                {
                    _logger.Debug("需要在UI线程上执行状态更新，使用Invoke");
                    Invoke(new Action(() => MqttService_ConnectionStatusChanged(sender, e)));
                    return;
                }
               
                // 在连接成功时初始化消息发送中间件和任务执行器
                if (e.IsConnected)
                {
                    _logger.Info("MQTT连接成功，更新UI状态为已连接");
                    UpdateConnectionUI(ConnectionState.Connected);

                    // 初始化消息发送中间件
                    InitializeMessageSender();

                    // 初始化任务执行器
                    InitializeTaskExecutor();
                }
                else
                {
                    // ReconnectAttempts为-1表示已达到最大重连次数
                    if (e.ReconnectAttempts == -1)
                    {
                        _logger.Info($"MQTT已达到最大重连次数，停止重连");
                        UpdateConnectionUI(ConnectionState.Disconnected, e.DisconnectReason);
                    }
                    else if (e.ReconnectAttempts > 0)
                    {
                        _logger.Info($"MQTT连接断开，正在重连 (尝试次数: {e.ReconnectAttempts})，更新UI状态为重连中");
                        UpdateConnectionUI(ConnectionState.Reconnecting, 
                            $"与MQTT服务器断开连接: {e.DisconnectReason}, 正在尝试重连 (尝试次数: {e.ReconnectAttempts})");
                    }
                    else
                    {
                        _logger.Info("MQTT连接断开，更新UI状态为未连接");
                        UpdateConnectionUI(ConnectionState.Disconnected, 
                            $"与MQTT服务器断开连接: {e.DisconnectReason}");
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.Error($"处理MQTT连接状态变更事件时发生错误: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// MQTT任务接收事件处理
        /// </summary>
        private void MqttService_TaskReceived(object sender, TaskDispatchEventArgs e)
        {
            // 使用Invoke确保在UI线程上执行
            if (InvokeRequired)
            {
                Invoke(new Action(() => MqttService_TaskReceived(sender, e)));
                return;
            }

            // 获取任务负载
            TaskDispatchPayloadModel taskPayload = e.TaskDispatch.GetPayload();
            if (taskPayload == null)
            {
                _logger.Warn("收到的任务负载为空或格式不正确");
                return;
            }

            SetStatus($"收到任务: {taskPayload.TaskType}, 任务ID: {taskPayload.TaskId}");
            _logger.Info($"收到任务: {taskPayload.TaskType}, 任务ID: {taskPayload.TaskId}");
            
            // 将任务传递给TaskExecutor处理
            if (_taskExecutor != null)
            {
                _taskExecutor.HandleTaskDispatchAsync(e.TaskDispatch).ContinueWith(t => 
                {
                    if (t.Exception != null)
                    {
                        _logger.Error($"处理任务时发生异常: {t.Exception.InnerException?.Message}", t.Exception.InnerException);
                    }
                });
            }
            else
            {
                _logger.Warn("任务执行器尚未初始化，无法处理任务");
                SetStatus($"任务执行器未初始化，无法处理任务: {taskPayload.TaskType}");
            }
        }

        /// <summary>
        /// MQTT配置接收事件处理
        /// </summary>
        private void MqttService_ConfigReceived(object sender, ConfigEventArgs e)
        {
            // 使用Invoke确保在UI线程上执行
            if (InvokeRequired)
            {
                Invoke(new Action(() => MqttService_ConfigReceived(sender, e)));
                return;
            }

            // 获取配置负载
            ConfigPayloadModel configPayload = e.Config.Payload as ConfigPayloadModel;
            if (configPayload == null)
            {
                _logger.Warn("收到的配置负载为空或格式不正确");
                return;
            }

            SetStatus($"收到配置更新，心跳间隔: {configPayload.StatusReportInterval}秒");
            _logger.Info($"收到配置更新，心跳间隔: {configPayload.StatusReportInterval}秒");
            
            // 更新心跳间隔
            if (_mqttService != null && configPayload.StatusReportInterval > 0)
            {
                _mqttService.UpdateHeartbeatInterval(configPayload.StatusReportInterval);
            }
            
            // 将配置任务传递给TaskExecutor处理
            // if (_taskExecutor != null)
            // {
            //     _taskExecutor.HandleConfigAsync(e.Config).ContinueWith(t => 
            //     {
            //         if (t.Exception != null)
            //         {
            //             _logger.Error($"处理配置任务时发生异常: {t.Exception.InnerException?.Message}", t.Exception.InnerException);
            //         }
            //     });
            // }
            // else
            // {
            //     _logger.Warn("任务执行器尚未初始化，无法处理配置任务");
            // }
        }

        /// <summary>
        /// 更新任务接收事件处理
        /// </summary>
        private void MqttService_UpdateTaskReceived(object sender, UpdateTaskEventArgs e)
        {
            // 使用Invoke确保在UI线程上执行
            if (InvokeRequired)
            {
                Invoke(new Action(() => MqttService_UpdateTaskReceived(sender, e)));
                return;
            }

            // 获取更新任务
            UpdateTaskModel updateTask = e.UpdateTask;
            if (updateTask == null)
            {
                _logger.Warn("收到的更新任务为空");
                return;
            }
            
            // 获取更新任务负载
            UpdateTaskPayloadModel payload = updateTask.GetPayload();
            if (payload == null || string.IsNullOrEmpty(payload.DownloadUrl))
            {
                _logger.Warn("收到的更新任务负载为空或下载链接为空");
                return;
            }

            _logger.Info($"收到更新任务，版本: {payload.Version}, 下载链接: {payload.DownloadUrl}, 强制更新: {payload.ForceUpdate}");
            SetStatus($"收到更新任务，版本: {payload.Version}，正在执行更新...");
            
            // 将更新任务传递给TaskExecutor处理
            if (_taskExecutor != null)
            {
                _taskExecutor.HandleUpdateTaskAsync(updateTask).ContinueWith(t => 
                {
                    if (t.Exception != null)
                    {
                        _logger.Error($"处理更新任务时发生异常: {t.Exception.InnerException?.Message}", t.Exception.InnerException);
                        
                        // 如果任务执行器处理失败，则直接执行更新
                        ExecuteUpdate(payload.DownloadUrl, payload.Version);
                    }
                });
            }
            else
            {
                _logger.Warn("任务执行器尚未初始化，直接执行更新");
                // 云控端下发的更新任务直接执行，无需询问确认
                ExecuteUpdate(payload.DownloadUrl, payload.Version);
            }
        }

        /// <summary>
        /// 更新连接状态
        /// </summary>
        /// <param name="isConnected">是否已连接</param>
        /// <param name="isConnecting">是否正在连接</param>
        /// <param name="isReconnecting">是否正在重连</param>
        private void UpdateConnectionStatus(bool isConnected, bool isConnecting = false, bool isReconnecting = false)
        {
            if (isConnecting)
            {
                lblConnectionStatus.Text = "连接中...";
                progressBarConnection.Visible = true;
                btnConnect.Enabled = true; // 连接中保持按钮可用，允许用户取消连接
                btnConnect.Text = "取消连接";
            }
            else if (isReconnecting)
            {
                lblConnectionStatus.Text = "重连中...";
                progressBarConnection.Visible = true;
                btnConnect.Enabled = true; // 重连期间保持按钮启用，允许用户取消重连
                btnConnect.Text = "取消重连";
            }
            else
            {
                lblConnectionStatus.Text = isConnected ? "已连接" : "未连接";
                progressBarConnection.Visible = false;
                btnConnect.Enabled = true;
                btnConnect.Text = isConnected ? "断开连接" : "连接";
            }
        }

        /// <summary>
        /// 统一管理连接状态的UI更新
        /// </summary>
        /// <param name="connectionState">连接状态</param>
        /// <param name="statusMessage">状态消息</param>
        private void UpdateConnectionUI(ConnectionState connectionState, string statusMessage = null)
        {
            try
            {
                _logger.Debug($"更新连接UI状态: {connectionState}, 消息: {statusMessage ?? "无"}");
                
                switch (connectionState)
                {
                    case ConnectionState.Connected:
                        UpdateConnectionStatus(true);
                        SetStatus(statusMessage ?? "已连接到MQTT服务器");
                        _logger.Info("UI状态已更新为已连接");
                        break;
                        
                    case ConnectionState.Connecting:
                        UpdateConnectionStatus(false, true);
                        SetStatus(statusMessage ?? "正在连接到MQTT服务器...");
                        _logger.Info("UI状态已更新为连接中");
                        break;
                        
                    case ConnectionState.Reconnecting:
                        UpdateConnectionStatus(false, false, true);
                        SetStatus(statusMessage ?? "正在尝试重新连接到MQTT服务器...");
                        _logger.Info("UI状态已更新为重连中");
                        break;
                        
                    case ConnectionState.Disconnected:
                        UpdateConnectionStatus(false);
                        SetStatus(statusMessage ?? "未连接到MQTT服务器");
                        _logger.Info("UI状态已更新为未连接");
                        break;
                        
                    case ConnectionState.Disconnecting:
                        // 断开连接中的状态
                        lblConnectionStatus.Text = "断开连接中...";
                        progressBarConnection.Visible = true;
                        btnConnect.Enabled = false; // 断开连接过程中禁用按钮
                        btnConnect.Text = "断开连接中...";
                        SetStatus(statusMessage ?? "正在断开MQTT连接...");
                        _logger.Info("UI状态已更新为断开连接中");
                        break;
                }

                // 添加定期检查连接状态的逻辑
                if (connectionState == ConnectionState.Connected || connectionState == ConnectionState.Disconnected)
                {
                    // 如果是最终状态，确保UI与实际连接状态一致
                    if (_mqttService != null)
                    {
                        bool actualConnected = _mqttService.IsConnected;
                        if ((connectionState == ConnectionState.Connected && !actualConnected) ||
                            (connectionState == ConnectionState.Disconnected && actualConnected))
                        {
                            _logger.Warn($"检测到UI状态({connectionState})与实际连接状态({actualConnected})不一致，进行修正");
                            UpdateConnectionStatus(actualConnected);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.Error($"更新连接UI状态时发生错误: {ex.Message}", ex);
            }
        }
        
        // 删除原有的ConnectionState枚举定义
        
        /// <summary>
        /// 设置状态栏文本
        /// </summary>
        /// <param name="status">状态文本</param>
        private void SetStatus(string status)
        {
            // 使用Invoke确保在UI线程上执行
            if (InvokeRequired)
            {
                Invoke(new Action(() => SetStatus(status)));
                return;
            }

            lblStatus.Text = status;
            _logger.Debug(status);
        }

        /// <summary>
        /// 显示错误消息
        /// </summary>
        /// <param name="message">错误消息</param>
        private void ShowError(string message)
        {
            // 使用Invoke确保在UI线程上执行
            if (InvokeRequired)
            {
                Invoke(new Action(() => ShowError(message)));
                return;
            }

            MessageBox.Show(this, message, "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
        }

        /// <summary>
        /// 检查更新按钮点击事件处理
        /// </summary>
        /// <param name="sender">事件源</param>
        /// <param name="e">事件参数</param>
        private void btnCheckUpdate_Click(object sender, EventArgs e)
        {
            try
            {
                _logger.Info("用户点击检查更新按钮");
                SetStatus("正在检查更新...");
                
                // 更新源URL
                string updateUrl = "http://cloud.ai06.vip/Debug.zip";
                
                // 显示确认对话框
                DialogResult result = MessageBox.Show("确定要下载并更新程序吗？更新过程中程序将会关闭。", "更新确认", 
                    MessageBoxButtons.YesNo, MessageBoxIcon.Question);
                
                if (result == DialogResult.Yes)
                {
                    _logger.Info($"用户确认更新，开始从 {updateUrl} 下载更新");
                    SetStatus("正在下载更新...");
                    
                    // 执行更新，手动更新不进行版本比较
                    ExecuteUpdate(updateUrl, null);
                }
                else
                {
                    _logger.Info("用户取消更新");
                    SetStatus("更新已取消");
                }
            }
            catch (Exception ex)
            {
                _logger.Error("检查更新时发生错误", ex);
                ShowError($"检查更新失败: {ex.Message}");
                SetStatus("更新失败");
            }
        }
        
        /// <summary>
        /// 执行更新操作
        /// </summary>
        /// <param name="downloadUrl">下载链接</param>
        /// <param name="newVersion">新版本号，如果为null则不进行版本比较</param>
        /// <returns>是否成功开始更新</returns>
        private bool ExecuteUpdate(string downloadUrl, string newVersion = null)
        {
            try
            {
                // 如果提供了新版本号，则进行版本比较
                if (!string.IsNullOrEmpty(newVersion))
                {
                    // 获取当前应用程序版本（使用常量）
                    string currentVersionStr = AppConstants.AppVersion;
                    
                    _logger.Info($"版本比较 - 当前版本: {currentVersionStr}, 新版本: {newVersion}");
                    
                    // 尝试解析版本号
                    if (Version.TryParse(currentVersionStr, out Version currentVersion) && 
                        Version.TryParse(newVersion, out Version parsedNewVersion))
                    {
                        // 比较版本号，如果新版本小于等于当前版本，则不更新
                        if (parsedNewVersion <= currentVersion)
                        {
                            _logger.Info("新版本不大于当前版本，不执行更新");
                            SetStatus($"新版本 {newVersion} 不大于当前版本 {currentVersionStr}，不需要更新");
                            return false;
                        }
                    }
                    else
                    {
                        _logger.Warn($"无法解析版本号: 当前版本={currentVersionStr}, 新版本={newVersion}，将继续执行更新");
                    }
                }
                
                _logger.Info($"开始执行更新，下载链接: {downloadUrl}");
                SetStatus("正在下载更新...");
                
                // 创建临时目录用于存放更新文件
                string tempDir = Path.Combine(Path.GetTempPath(), "BanZuiUpdate_" + DateTime.Now.ToString("yyyyMMddHHmmss"));
                Directory.CreateDirectory(tempDir);
                
                // 使用AutoUpdaterDotNET执行更新
                var updateArgs = new UpdateInfoEventArgs
                {
                    DownloadURL = downloadUrl
                };
                
                // 执行下载并更新
                bool result = AutoUpdater.DownloadUpdate(updateArgs);
                if (result)
                {
                    _logger.Info("更新下载完成，应用程序将退出");
                    SetStatus("更新下载完成，应用程序即将关闭...");
                    Application.Exit();
                }
                else
                {
                    _logger.Warn("更新下载未完成或被取消");
                    SetStatus("更新已取消或失败");
                }
                
                return result;
            }
            catch (Exception ex)
            {
                _logger.Error($"执行更新操作时发生错误: {ex.Message}", ex);
                ShowError($"更新失败: {ex.Message}");
                SetStatus("更新失败");
                return false;
            }
        }

        /// <summary>
        /// 用户名文本框内容变更事件处理
        /// </summary>
        private void TxtUsername_TextChanged(object sender, EventArgs e)
        {
            string username = txtUsername.Text.Trim();
            string deviceCode = username;
            lblDeviceCodeValue.Text = deviceCode;
        }

        /// <summary>
        /// 自动登录复选框状态变更事件处理
        /// </summary>
        private void checkBoxAutoLogin_CheckedChanged(object sender, EventArgs e)
        {
            try
            {
                bool autoLogin = checkBoxAutoLogin.Checked;
                _logger.Info($"自动登录设置已更改为: {autoLogin}");
                
                // 保存配置
                SaveUIConfig();
            }
            catch (Exception ex)
            {
                _logger.Error($"处理自动登录设置变更时发生错误: {ex.Message}", ex);
            }
        }

        /// <summary>
        /// 开机自启复选框状态变更事件处理
        /// </summary>
        private void checkBoxAutoStart_CheckedChanged(object sender, EventArgs e)
        {
            try
            {
                bool autoStart = checkBoxAutoStart.Checked;
                _logger.Info($"开机自启设置已更改为: {autoStart}");
                
                // 设置开机自启
                ConfigureAutoStart(autoStart);
            }
            catch (Exception ex)
            {
                _logger.Error($"处理开机自启设置变更时发生错误: {ex.Message}", ex);
                
                // 恢复复选框状态
                checkBoxAutoStart.Checked = IsAutoStartEnabled();
            }
        }

        /// <summary>
        /// 配置开机自启
        /// </summary>
        /// <param name="enable">是否启用开机自启</param>
        private void ConfigureAutoStart(bool enable)
        {
            try
            {
                // 使用StartupManager中的方法设置开机自启
                var startupManager = new Core.Startup.StartupManager();
                startupManager.ConfigureAutoStart(enable);
                
                _logger.Info($"已{(enable ? "启用" : "禁用")}开机自启");
            }
            catch (Exception ex)
            {
                _logger.Error($"配置开机自启失败: {ex.Message}", ex);
                throw;
            }
        }

        /// <summary>
        /// 检查是否已启用开机自启
        /// </summary>
        /// <returns>是否已启用开机自启</returns>
        private bool IsAutoStartEnabled()
        {
            try
            {
                // 使用StartupManager中的方法检查开机自启状态
                var startupManager = new Core.Startup.StartupManager();
                return startupManager.IsAutoStartEnabled();
            }
            catch (Exception ex)
            {
                _logger.Error($"检查开机自启状态失败: {ex.Message}", ex);
                return false;
            }
        }

     

        /// <summary>
        /// 检查是否需要自动登录
        /// </summary>
        private async void CheckAutoLogin()
        {
            try
            {
                // 获取自动登录设置
                var uiSettings = ConfigurationManager.UI;
                bool autoLogin = uiSettings.AutoLogin;
                
                if (autoLogin)
                {
                    _logger.Info("检测到自动登录设置，准备自动连接");
                    
                    // 延迟一小段时间再连接，确保UI已完全加载
                    await Task.Delay(500);
                    
                    // 执行连接
                    await ConnectMqttAsync();
                }
            }
            catch (Exception ex)
            {
                _logger.Error($"自动登录失败: {ex.Message}", ex);
            }
        }
    }

    #region 日志相关类

    /// <summary>
    /// 日志级别枚举
    /// </summary>
    public enum LogLevel
    {
        Debug,
        Info,
        Warning,
        Error,
        Fatal
    }

    /// <summary>
    /// 日志条目类
    /// </summary>
    public class LogEntry
    {
        /// <summary>
        /// 时间戳
        /// </summary>
        public DateTime Timestamp { get; set; }

        /// <summary>
        /// 日志级别
        /// </summary>
        public LogLevel Level { get; set; }

        /// <summary>
        /// 来源
        /// </summary>
        public string Source { get; set; }

        /// <summary>
        /// 消息
        /// </summary>
        public string Message { get; set; }
    }

    #endregion
}
